home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Tool Chest / !Interfaces / Universal Interfaces 2.0a1 / PInterfaces / Resources.p < prev    next >
Encoding:
Text File  |  1994-07-17  |  8.9 KB  |  338 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Resources.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a1.  ETO #15, MPW prerelease.  Sunday, July 17, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT Resources;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __RESOURCES__}
  27. {$SETC __RESOURCES__ := 1}
  28.  
  29. {$I+}
  30. {$SETC ResourcesIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {    ConditionalMacros.p                                            }
  38.  
  39. {$IFC UNDEFINED __MIXEDMODE__}
  40. {$I MixedMode.p}
  41. {$ENDC}
  42.  
  43. {$IFC UNDEFINED __FILES__}
  44. {$I Files.p}
  45. {$ENDC}
  46. {    OSUtils.p                                                    }
  47.  
  48. {$PUSH}
  49. {$ALIGN MAC68K}
  50. {$LibExport+}
  51.  
  52. CONST
  53.     resSysHeap                    = 64;                            {System or application heap?}
  54.     resPurgeable                = 32;                            {Purgeable resource?}
  55.     resLocked                    = 16;                            {Load it in locked?}
  56.     resProtected                = 8;                            {Protected?}
  57.     resPreload                    = 4;                            {Load in on OpenResFile?}
  58.     resChanged                    = 2;                            {Resource changed?}
  59.     mapReadOnly                    = 128;                            {Resource file read-only}
  60.     mapCompact                    = 64;                            {Compact resource file}
  61.     mapChanged                    = 32;                            {Write map out at update}
  62.     kResFileNotOpened            = -1;                            {ref num return as error when opening a resource file}
  63.     kSystemResFile                = 0;                            {this is the default ref num to the system file}
  64.  
  65. TYPE
  66.     {
  67.         ResErrProcPtr uses register based parameters on the 68k and cannot
  68.         be written in or called from a high-level language without the help of
  69.         mixed mode or assembly glue.
  70.  
  71.         In:
  72.          => thErr           D0.W
  73.     }
  74.     ResErrProcPtr = ProcPtr;  { PROCEDURE ResErr(thErr: OSErr); }
  75.     ResErrUPP = UniversalProcPtr;
  76.  
  77. CONST
  78.     uppResErrProcInfo = $00001002; { Register PROCEDURE (2 bytes in D0); }
  79.  
  80. FUNCTION NewResErrProc(userRoutine: ResErrProcPtr): ResErrUPP;
  81.     {$IFC NOT GENERATINGCFM }
  82.     INLINE $2E9F;
  83.     {$ENDC}
  84.  
  85. PROCEDURE CallResErrProc(thErr: OSErr; userRoutine: ResErrUPP);
  86.     {$IFC NOT GENERATINGCFM}
  87.     {To be implemented:  Glue to move parameters into registers.}
  88.     {$ENDC}
  89.  
  90. FUNCTION InitResources: INTEGER;
  91.     {$IFC NOT GENERATINGCFM}
  92.     INLINE $A995;
  93.     {$ENDC}
  94. PROCEDURE RsrcZoneInit;
  95.     {$IFC NOT GENERATINGCFM}
  96.     INLINE $A996;
  97.     {$ENDC}
  98. PROCEDURE CloseResFile(refNum: INTEGER);
  99.     {$IFC NOT GENERATINGCFM}
  100.     INLINE $A99A;
  101.     {$ENDC}
  102. FUNCTION ResError: INTEGER;
  103.     {$IFC NOT GENERATINGCFM}
  104.     INLINE $A9AF;
  105.     {$ENDC}
  106. FUNCTION CurResFile: INTEGER;
  107.     {$IFC NOT GENERATINGCFM}
  108.     INLINE $A994;
  109.     {$ENDC}
  110. FUNCTION HomeResFile(theResource: Handle): INTEGER;
  111.     {$IFC NOT GENERATINGCFM}
  112.     INLINE $A9A4;
  113.     {$ENDC}
  114. PROCEDURE CreateResFile(fileName: ConstStr255Param);
  115.     {$IFC NOT GENERATINGCFM}
  116.     INLINE $A9B1;
  117.     {$ENDC}
  118. FUNCTION OpenResFile(fileName: ConstStr255Param): INTEGER;
  119.     {$IFC NOT GENERATINGCFM}
  120.     INLINE $A997;
  121.     {$ENDC}
  122. PROCEDURE UseResFile(refNum: INTEGER);
  123.     {$IFC NOT GENERATINGCFM}
  124.     INLINE $A998;
  125.     {$ENDC}
  126. FUNCTION CountTypes: INTEGER;
  127.     {$IFC NOT GENERATINGCFM}
  128.     INLINE $A99E;
  129.     {$ENDC}
  130. FUNCTION Count1Types: INTEGER;
  131.     {$IFC NOT GENERATINGCFM}
  132.     INLINE $A81C;
  133.     {$ENDC}
  134. PROCEDURE GetIndType(VAR theType: ResType; index: INTEGER);
  135.     {$IFC NOT GENERATINGCFM}
  136.     INLINE $A99F;
  137.     {$ENDC}
  138. PROCEDURE Get1IndType(VAR theType: ResType; index: INTEGER);
  139.     {$IFC NOT GENERATINGCFM}
  140.     INLINE $A80F;
  141.     {$ENDC}
  142. PROCEDURE SetResLoad(load: BOOLEAN);
  143.     {$IFC NOT GENERATINGCFM}
  144.     INLINE $A99B;
  145.     {$ENDC}
  146. FUNCTION CountResources(theType: ResType): INTEGER;
  147.     {$IFC NOT GENERATINGCFM}
  148.     INLINE $A99C;
  149.     {$ENDC}
  150. FUNCTION Count1Resources(theType: ResType): INTEGER;
  151.     {$IFC NOT GENERATINGCFM}
  152.     INLINE $A80D;
  153.     {$ENDC}
  154. FUNCTION GetIndResource(theType: ResType; index: INTEGER): Handle;
  155.     {$IFC NOT GENERATINGCFM}
  156.     INLINE $A99D;
  157.     {$ENDC}
  158. FUNCTION Get1IndResource(theType: ResType; index: INTEGER): Handle;
  159.     {$IFC NOT GENERATINGCFM}
  160.     INLINE $A80E;
  161.     {$ENDC}
  162. FUNCTION GetResource(theType: ResType; theID: INTEGER): Handle;
  163.     {$IFC NOT GENERATINGCFM}
  164.     INLINE $A9A0;
  165.     {$ENDC}
  166. FUNCTION Get1Resource(theType: ResType; theID: INTEGER): Handle;
  167.     {$IFC NOT GENERATINGCFM}
  168.     INLINE $A81F;
  169.     {$ENDC}
  170. FUNCTION GetNamedResource(theType: ResType; name: ConstStr255Param): Handle;
  171.     {$IFC NOT GENERATINGCFM}
  172.     INLINE $A9A1;
  173.     {$ENDC}
  174. FUNCTION Get1NamedResource(theType: ResType; name: ConstStr255Param): Handle;
  175.     {$IFC NOT GENERATINGCFM}
  176.     INLINE $A820;
  177.     {$ENDC}
  178. PROCEDURE LoadResource(theResource: Handle);
  179.     {$IFC NOT GENERATINGCFM}
  180.     INLINE $A9A2;
  181.     {$ENDC}
  182. PROCEDURE ReleaseResource(theResource: Handle);
  183.     {$IFC NOT GENERATINGCFM}
  184.     INLINE $A9A3;
  185.     {$ENDC}
  186. PROCEDURE DetachResource(theResource: Handle);
  187.     {$IFC NOT GENERATINGCFM}
  188.     INLINE $A992;
  189.     {$ENDC}
  190. FUNCTION UniqueID(theType: ResType): INTEGER;
  191.     {$IFC NOT GENERATINGCFM}
  192.     INLINE $A9C1;
  193.     {$ENDC}
  194. FUNCTION Unique1ID(theType: ResType): INTEGER;
  195.     {$IFC NOT GENERATINGCFM}
  196.     INLINE $A810;
  197.     {$ENDC}
  198. FUNCTION GetResAttrs(theResource: Handle): INTEGER;
  199.     {$IFC NOT GENERATINGCFM}
  200.     INLINE $A9A6;
  201.     {$ENDC}
  202. PROCEDURE GetResInfo(theResource: Handle; VAR theID: INTEGER; VAR theType: ResType; VAR name: Str255);
  203.     {$IFC NOT GENERATINGCFM}
  204.     INLINE $A9A8;
  205.     {$ENDC}
  206. PROCEDURE SetResInfo(theResource: Handle; theID: INTEGER; name: ConstStr255Param);
  207.     {$IFC NOT GENERATINGCFM}
  208.     INLINE $A9A9;
  209.     {$ENDC}
  210. PROCEDURE AddResource(theData: Handle; theType: ResType; theID: INTEGER; name: ConstStr255Param);
  211.     {$IFC NOT GENERATINGCFM}
  212.     INLINE $A9AB;
  213.     {$ENDC}
  214. FUNCTION GetResourceSizeOnDisk(theResource: Handle): LONGINT;
  215.     {$IFC NOT GENERATINGCFM}
  216.     INLINE $A9A5;
  217.     {$ENDC}
  218. FUNCTION GetMaxResourceSize(theResource: Handle): LONGINT;
  219.     {$IFC NOT GENERATINGCFM}
  220.     INLINE $A821;
  221.     {$ENDC}
  222. FUNCTION RsrcMapEntry(theResource: Handle): LONGINT;
  223.     {$IFC NOT GENERATINGCFM}
  224.     INLINE $A9C5;
  225.     {$ENDC}
  226. PROCEDURE SetResAttrs(theResource: Handle; attrs: INTEGER);
  227.     {$IFC NOT GENERATINGCFM}
  228.     INLINE $A9A7;
  229.     {$ENDC}
  230. PROCEDURE ChangedResource(theResource: Handle);
  231.     {$IFC NOT GENERATINGCFM}
  232.     INLINE $A9AA;
  233.     {$ENDC}
  234. PROCEDURE RemoveResource(theResource: Handle);
  235.     {$IFC NOT GENERATINGCFM}
  236.     INLINE $A9AD;
  237.     {$ENDC}
  238. PROCEDURE UpdateResFile(refNum: INTEGER);
  239.     {$IFC NOT GENERATINGCFM}
  240.     INLINE $A999;
  241.     {$ENDC}
  242. PROCEDURE WriteResource(theResource: Handle);
  243.     {$IFC NOT GENERATINGCFM}
  244.     INLINE $A9B0;
  245.     {$ENDC}
  246. PROCEDURE SetResPurge(install: BOOLEAN);
  247.     {$IFC NOT GENERATINGCFM}
  248.     INLINE $A993;
  249.     {$ENDC}
  250. FUNCTION GetResFileAttrs(refNum: INTEGER): INTEGER;
  251.     {$IFC NOT GENERATINGCFM}
  252.     INLINE $A9F6;
  253.     {$ENDC}
  254. PROCEDURE SetResFileAttrs(refNum: INTEGER; attrs: INTEGER);
  255.     {$IFC NOT GENERATINGCFM}
  256.     INLINE $A9F7;
  257.     {$ENDC}
  258. FUNCTION OpenRFPerm(fileName: ConstStr255Param; vRefNum: INTEGER; permission: ByteParameter): INTEGER;
  259.     {$IFC NOT GENERATINGCFM}
  260.     INLINE $A9C4;
  261.     {$ENDC}
  262. FUNCTION RGetResource(theType: ResType; theID: INTEGER): Handle;
  263.     {$IFC NOT GENERATINGCFM}
  264.     INLINE $A80C;
  265.     {$ENDC}
  266. {$IFC SystemSevenOrLater }
  267. FUNCTION HOpenResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param; permission: ByteParameter): INTEGER;
  268.     {$IFC NOT GENERATINGCFM}
  269.     INLINE $A81A;
  270.     {$ENDC}
  271. {$ELSEC}
  272. FUNCTION HOpenResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param; permission: ByteParameter): INTEGER;
  273. {$ENDC}
  274. {$IFC SystemSevenOrLater }
  275. PROCEDURE HCreateResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param);
  276.     {$IFC NOT GENERATINGCFM}
  277.     INLINE $A81B;
  278.     {$ENDC}
  279. {$ELSEC}
  280. PROCEDURE HCreateResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param);
  281. {$ENDC}
  282. FUNCTION FSpOpenResFile(spec: FSSpec; permission: ByteParameter): INTEGER;
  283.     {$IFC NOT GENERATINGCFM}
  284.     INLINE $700D, $AA52;
  285.     {$ENDC}
  286. PROCEDURE FSpCreateResFile(spec: FSSpec; creator: OSType; fileType: OSType; scriptTag: ScriptCode);
  287.     {$IFC NOT GENERATINGCFM}
  288.     INLINE $700E, $AA52;
  289.     {$ENDC}
  290. {  partial resource calls  }
  291. PROCEDURE ReadPartialResource(theResource: Handle; offset: LONGINT; buffer: UNIV Ptr; count: LONGINT);
  292.     {$IFC NOT GENERATINGCFM}
  293.     INLINE $7001, $A822;
  294.     {$ENDC}
  295. PROCEDURE WritePartialResource(theResource: Handle; offset: LONGINT; buffer: UNIV Ptr; count: LONGINT);
  296.     {$IFC NOT GENERATINGCFM}
  297.     INLINE $7002, $A822;
  298.     {$ENDC}
  299. PROCEDURE SetResourceSize(theResource: Handle; newSize: LONGINT);
  300.     {$IFC NOT GENERATINGCFM}
  301.     INLINE $7003, $A822;
  302.     {$ENDC}
  303. FUNCTION GetNextFOND(fondHandle: Handle): Handle;
  304.     {$IFC NOT GENERATINGCFM}
  305.     INLINE $700A, $A822;
  306.     {$ENDC}
  307. { Use TempInsertROMMap to force the ROM resource map to be
  308.    inserted into the chain in front of the system. Note that
  309.    this call is only temporary - the modified resource chain
  310.    is only used for the next call to the resource manager.
  311.    See IM IV 19 for more information. }
  312. PROCEDURE TempInsertROMMap(tempResLoad: BOOLEAN);
  313. {$IFC OLDROUTINENAMES }
  314. FUNCTION SizeResource(theResource: Handle): LONGINT;
  315.     {$IFC NOT GENERATINGCFM}
  316.     INLINE $A9A5;
  317.     {$ENDC}
  318. FUNCTION MaxSizeRsrc(theResource: Handle): LONGINT;
  319.     {$IFC NOT GENERATINGCFM}
  320.     INLINE $A821;
  321.     {$ENDC}
  322. PROCEDURE RmveResource(theResource: Handle);
  323.     {$IFC NOT GENERATINGCFM}
  324.     INLINE $A9AD;
  325.     {$ENDC}
  326. {$ENDC}
  327.  
  328. {$ALIGN RESET}
  329. {$POP}
  330.  
  331. {$SETC UsingIncludes := ResourcesIncludes}
  332.  
  333. {$ENDC} {__RESOURCES__}
  334.  
  335. {$IFC NOT UsingIncludes}
  336.  END.
  337. {$ENDC}
  338.